/**
 * helper.js
 * 基础工具函数库
 * PLM项目专用版本
 */

// 尝试导入全局辅助模块
let globalHelper;
try {
  globalHelper = require('../../../helpers/helper.js');
  console.log('成功加载全局helper');
} catch (e) {
  console.warn('加载全局helper失败，使用本地实现', e);
  globalHelper = null;
}

// 本地实现的基本工具函数
const localImpl = {
  /**
   * 生成随机字符串
   * @param {number} length - 随机字符串长度
   * @returns {string} 随机字符串
   */
  genRandomString: function(length = 32) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  },
  
  /**
   * 生成随机数字
   * @param {number} min - 最小值
   * @param {number} max - 最大值
   * @returns {number} 随机数字
   */
  genRandomNum: function(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  },
  
  /**
   * 检查是否已定义
   * @param {*} val - 要检查的值
   * @returns {boolean} 是否已定义
   */
  isDefined: function(val) {
    return val !== undefined && val !== null;
  },
  
  /**
   * 判断是否为空
   * @param {*} val - 要检查的值
   * @returns {boolean} 是否为空
   */
  isEmpty: function(val) {
    if (val === null || val === undefined) return true;
    
    if (typeof val === 'string') return val.trim().length === 0;
    
    if (Array.isArray(val)) return val.length === 0;
    
    if (typeof val === 'object') return Object.keys(val).length === 0;
    
    return false;
  },
  
  /**
   * 获取对象指定字段
   * @param {Object} obj - 源对象
   * @param {Array<string>} fields - 字段列表
   * @returns {Object} 包含指定字段的对象
   */
  getFields: function(obj, fields) {
    if (!obj || !fields || !Array.isArray(fields)) return {};
    
    const result = {};
    fields.forEach(field => {
      if (obj[field] !== undefined) {
        result[field] = obj[field];
      }
    });
    
    return result;
  },
  
  /**
   * 对象过滤器
   * @param {Object} obj - 源对象
   * @param {Function} predicate - 过滤函数
   * @returns {Object} 过滤后的对象
   */
  objFilter: function(obj, predicate) {
    const result = {};
    
    Object.keys(obj).forEach(key => {
      if (predicate(obj[key], key)) {
        result[key] = obj[key];
      }
    });
    
    return result;
  },
  
  /**
   * 对象映射
   * @param {Object} obj - 源对象
   * @param {Function} mapper - 映射函数
   * @returns {Object} 映射后的对象
   */
  objMap: function(obj, mapper) {
    const result = {};
    
    Object.keys(obj).forEach(key => {
      result[key] = mapper(obj[key], key);
    });
    
    return result;
  },
  
  /**
   * 检查是否为对象
   * @param {*} val - 要检查的值
   * @returns {boolean} 是否为对象
   */
  isObject: function(val) {
    return val !== null && typeof val === 'object' && !Array.isArray(val);
  },
  
  /**
   * 深拷贝对象
   * @param {*} obj - 源对象
   * @returns {*} 拷贝后的对象
   */
  deepClone: function(obj) {
    if (obj === null || typeof obj !== 'object') return obj;
    
    // 处理日期对象
    if (obj instanceof Date) return new Date(obj);
    
    // 处理数组
    if (Array.isArray(obj)) {
      return obj.map(item => this.deepClone(item));
    }
    
    // 处理普通对象
    const cloned = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        cloned[key] = this.deepClone(obj[key]);
      }
    }
    
    return cloned;
  },
  
  /**
   * 格式化数字为指定小数位数
   * @param {number} num - 源数字
   * @param {number} digits - 小数位数
   * @returns {number} 格式化后的数字
   */
  formatNumber: function(num, digits = 2) {
    if (isNaN(num)) return 0;
    return parseFloat(num.toFixed(digits));
  }
};

// 使用全局实现或本地实现
const helper = globalHelper || localImpl;

// 导出模块
module.exports = helper; 